When a user runs an application or program on a computer, the user is actually requesting the operating system to load and run one or more processes associated with that application. For example, an application can have a primary process that is loaded initially and additional auxiliary processes which may be loaded as needed.
From the point that applications load, the user expects to be able to constantly and quickly interact with each application whenever they desire. This constant interaction is frequently possible when just a small amount of processing is performed between user events, such as a button click or a menu item request in the application. For example, a word processor performs most of its processing in small chunks and the user is able to access the user interface seemingly instantaneously.
Other applications may not be available to the user for a certain period after the user has requested a complex or time-consuming operation. The period may be a few seconds or sometimes longer. Some applications and processes are able to present the user with a screen that notifies a user of the status of their request. Unfortunately, many processes cannot provide this status. This is especially true where the process running on the user's side has requested information from a process running on a remote server or database. In these situations, the process will make its request and then appear to freeze as the request is performed remotely from the local machine.
Even when an application presents a screen to the user and tells the user that the application or process is busy performing operations, the user may not know whether the service request is being processed or whether the application has crashed. This is especially true for an application that is not able to present a user with a progress screen. The user interface in such a situation will appear to be frozen but the application will actually be performing normal processing behind the scenes. Either the user must be patient in this situation or the user can decide to try to terminate the application or process. To terminate an application's processes, the user opens the operating system's task manager and requests that the specific processes terminate immediately.
If the user decides to terminate a process, this can be a problem in many situations because the process is not allowed to terminate normally when a user shutdown is initiated. This means that the normal cleanup and shutdown functions cannot be activated. Of course, there are legitimate situations where processes should be shutdown. A process should be shutdown when it has crashed or there has been a process or system malfunction. In these cases, the process should be stopped and restarted.
If the process is still working, then the user generally does not want to shut down the process because at some point the process will complete the task that the user has requested. Shutting down a process prematurely can cause serious problems for the process or the entire system. Shutting down the process prematurely can cause corruption in the process itself and cause corruption to other processes or a service from which the original process has requested information. One situation where this might happen is a process that is requesting information from or trying to write to a database. If the process is writing the information to the database and then the process is prematurely terminated, the database may be corrupted and/or left in a partially completed state.